Termination of the given ITRSProblem could not be shown:
↳ ITRS
↳ ITRStoIDPProof
ITRS problem:
The following domains are used:
z
The TRS R consists of the following rules:
cond1(FALSE, x) → x
cond2(FALSE, x) → f(+@z(*@z(3@z, x), 1@z))
f(x) → cond1(>@z(x, 1@z), x)
cond2(TRUE, x) → f(/@z(x, 2@z))
cond1(TRUE, x) → cond2(=@z(%@z(x, 2@z), 0@z), x)
The set Q consists of the following terms:
cond1(FALSE, x0)
cond2(FALSE, x0)
f(x0)
cond2(TRUE, x0)
cond1(TRUE, x0)
Added dependency pairs
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
I DP problem:
The following domains are used:
z
The ITRS R consists of the following rules:
cond1(FALSE, x) → x
cond2(FALSE, x) → f(+@z(*@z(3@z, x), 1@z))
f(x) → cond1(>@z(x, 1@z), x)
cond2(TRUE, x) → f(/@z(x, 2@z))
cond1(TRUE, x) → cond2(=@z(%@z(x, 2@z), 0@z), x)
The integer pair graph contains the following rules and edges:
(0): COND2(TRUE, x[0]) → F(/@z(x[0], 2@z))
(1): COND2(FALSE, x[1]) → F(+@z(*@z(3@z, x[1]), 1@z))
(2): COND1(TRUE, x[2]) → COND2(=@z(%@z(x[2], 2@z), 0@z), x[2])
(3): F(x[3]) → COND1(>@z(x[3], 1@z), x[3])
(0) -> (3), if ((/@z(x[0], 2@z) →* x[3]))
(1) -> (3), if ((+@z(*@z(3@z, x[1]), 1@z) →* x[3]))
(2) -> (0), if ((x[2] →* x[0])∧(=@z(%@z(x[2], 2@z), 0@z) →* TRUE))
(2) -> (1), if ((x[2] →* x[1])∧(=@z(%@z(x[2], 2@z), 0@z) →* FALSE))
(3) -> (2), if ((x[3] →* x[2])∧(>@z(x[3], 1@z) →* TRUE))
The set Q consists of the following terms:
cond1(FALSE, x0)
cond2(FALSE, x0)
f(x0)
cond2(TRUE, x0)
cond1(TRUE, x0)
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
I DP problem:
The following domains are used:
z
R is empty.
The integer pair graph contains the following rules and edges:
(0): COND2(TRUE, x[0]) → F(/@z(x[0], 2@z))
(1): COND2(FALSE, x[1]) → F(+@z(*@z(3@z, x[1]), 1@z))
(2): COND1(TRUE, x[2]) → COND2(=@z(%@z(x[2], 2@z), 0@z), x[2])
(3): F(x[3]) → COND1(>@z(x[3], 1@z), x[3])
(0) -> (3), if ((/@z(x[0], 2@z) →* x[3]))
(1) -> (3), if ((+@z(*@z(3@z, x[1]), 1@z) →* x[3]))
(2) -> (0), if ((x[2] →* x[0])∧(=@z(%@z(x[2], 2@z), 0@z) →* TRUE))
(2) -> (1), if ((x[2] →* x[1])∧(=@z(%@z(x[2], 2@z), 0@z) →* FALSE))
(3) -> (2), if ((x[3] →* x[2])∧(>@z(x[3], 1@z) →* TRUE))
The set Q consists of the following terms:
cond1(FALSE, x0)
cond2(FALSE, x0)
f(x0)
cond2(TRUE, x0)
cond1(TRUE, x0)
Represented integers and predefined function symbols by Terms
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
COND2(true, x[0]) → F(div_int(x[0], pos(s(s(0)))))
COND2(false, x[1]) → F(plus_int(pos(s(0)), mult_int(pos(s(s(s(0)))), x[1])))
COND1(true, x[2]) → COND2(equal_int(mod_int(x[2], pos(s(s(0)))), pos(0)), x[2])
F(x[3]) → COND1(greater_int(x[3], pos(s(0))), x[3])
The TRS R consists of the following rules:
div_int(pos(x), pos(s(y))) → pos(div_nat(x, s(y)))
div_int(pos(x), neg(s(y))) → neg(div_nat(x, s(y)))
div_int(neg(x), pos(s(y))) → neg(div_nat(x, s(y)))
div_int(neg(x), neg(s(y))) → pos(div_nat(x, s(y)))
div_nat(0, s(y)) → 0
div_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), div_nat(minus_nat_s(x, y), s(y)), 0)
greatereq_int(pos(x), pos(0)) → true
greatereq_int(neg(0), pos(0)) → true
greatereq_int(neg(0), neg(y)) → true
greatereq_int(pos(x), neg(y)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(neg(x), pos(s(y))) → false
greatereq_int(neg(s(x)), pos(0)) → false
greatereq_int(neg(s(x)), neg(0)) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
greatereq_int(neg(s(x)), neg(s(y))) → greatereq_int(neg(x), neg(y))
if(true, x, y) → x
if(false, x, y) → y
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(neg(x), pos(y)) → minus_nat(y, x)
plus_int(neg(x), neg(y)) → neg(plus_nat(x, y))
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
mult_int(pos(x), pos(y)) → pos(mult_nat(x, y))
mult_int(pos(x), neg(y)) → neg(mult_nat(x, y))
mult_int(neg(x), pos(y)) → neg(mult_nat(x, y))
mult_int(neg(x), neg(y)) → pos(mult_nat(x, y))
mult_nat(0, y) → 0
mult_nat(s(x), 0) → 0
mult_nat(s(x), s(y)) → plus_nat(mult_nat(x, s(y)), s(y))
equal_int(pos(0), pos(0)) → true
equal_int(neg(0), pos(0)) → true
equal_int(neg(0), neg(0)) → true
equal_int(pos(0), neg(0)) → true
equal_int(pos(0), pos(s(y))) → false
equal_int(neg(0), pos(s(y))) → false
equal_int(pos(0), neg(s(y))) → false
equal_int(neg(0), neg(s(y))) → false
equal_int(pos(s(x)), pos(0)) → false
equal_int(pos(s(x)), neg(0)) → false
equal_int(neg(s(x)), pos(0)) → false
equal_int(neg(s(x)), neg(0)) → false
equal_int(pos(s(x)), neg(s(y))) → false
equal_int(neg(s(x)), pos(s(y))) → false
equal_int(pos(s(x)), pos(s(y))) → equal_int(pos(x), pos(y))
equal_int(neg(s(x)), neg(s(y))) → equal_int(neg(x), neg(y))
mod_int(pos(x), pos(y)) → pos(mod_nat(x, y))
mod_int(pos(x), neg(y)) → pos(mod_nat(x, y))
mod_int(neg(x), pos(y)) → neg(mod_nat(x, y))
mod_int(neg(x), neg(y)) → neg(mod_nat(x, y))
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
greater_int(pos(0), pos(0)) → false
greater_int(pos(0), neg(0)) → false
greater_int(neg(0), pos(0)) → false
greater_int(neg(0), neg(0)) → false
greater_int(pos(0), pos(s(y))) → false
greater_int(neg(0), pos(s(y))) → false
greater_int(pos(0), neg(s(y))) → true
greater_int(neg(0), neg(s(y))) → true
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(0)) → false
greater_int(pos(s(x)), neg(0)) → true
greater_int(neg(s(x)), neg(0)) → false
greater_int(pos(s(x)), neg(s(y))) → true
greater_int(neg(s(x)), pos(s(y))) → false
greater_int(pos(s(x)), pos(s(y))) → greater_int(pos(x), pos(y))
greater_int(neg(s(x)), neg(s(y))) → greater_int(neg(x), neg(y))
The set Q consists of the following terms:
cond1(false, x0)
cond2(false, x0)
f(x0)
cond2(true, x0)
cond1(true, x0)
div_int(pos(x0), pos(s(x1)))
div_int(pos(x0), neg(s(x1)))
div_int(neg(x0), pos(s(x1)))
div_int(neg(x0), neg(s(x1)))
div_nat(0, s(x0))
div_nat(s(x0), s(x1))
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
mult_int(pos(x0), pos(x1))
mult_int(pos(x0), neg(x1))
mult_int(neg(x0), pos(x1))
mult_int(neg(x0), neg(x1))
mult_nat(0, x0)
mult_nat(s(x0), 0)
mult_nat(s(x0), s(x1))
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_int(pos(x0), pos(x1))
mod_int(pos(x0), neg(x1))
mod_int(neg(x0), pos(x1))
mod_int(neg(x0), neg(x1))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
Q DP problem:
The TRS P consists of the following rules:
COND2(true, x[0]) → F(div_int(x[0], pos(s(s(0)))))
COND2(false, x[1]) → F(plus_int(pos(s(0)), mult_int(pos(s(s(s(0)))), x[1])))
COND1(true, x[2]) → COND2(equal_int(mod_int(x[2], pos(s(s(0)))), pos(0)), x[2])
F(x[3]) → COND1(greater_int(x[3], pos(s(0))), x[3])
The TRS R consists of the following rules:
mod_int(pos(x), pos(y)) → pos(mod_nat(x, y))
mod_int(neg(x), pos(y)) → neg(mod_nat(x, y))
equal_int(pos(0), pos(0)) → true
equal_int(neg(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
equal_int(neg(s(x)), pos(0)) → false
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
greater_int(pos(0), pos(s(y))) → false
greater_int(neg(0), pos(s(y))) → false
greater_int(neg(s(x)), pos(s(y))) → false
greater_int(pos(s(x)), pos(s(y))) → greater_int(pos(x), pos(y))
greater_int(pos(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
div_int(pos(x), pos(s(y))) → pos(div_nat(x, s(y)))
div_int(neg(x), pos(s(y))) → neg(div_nat(x, s(y)))
div_nat(0, s(y)) → 0
div_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), div_nat(minus_nat_s(x, y), s(y)), 0)
mult_int(pos(x), pos(y)) → pos(mult_nat(x, y))
mult_int(pos(x), neg(y)) → neg(mult_nat(x, y))
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
mult_nat(0, y) → 0
mult_nat(s(x), 0) → 0
mult_nat(s(x), s(y)) → plus_nat(mult_nat(x, s(y)), s(y))
The set Q consists of the following terms:
cond1(false, x0)
cond2(false, x0)
f(x0)
cond2(true, x0)
cond1(true, x0)
div_int(pos(x0), pos(s(x1)))
div_int(pos(x0), neg(s(x1)))
div_int(neg(x0), pos(s(x1)))
div_int(neg(x0), neg(s(x1)))
div_nat(0, s(x0))
div_nat(s(x0), s(x1))
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
mult_int(pos(x0), pos(x1))
mult_int(pos(x0), neg(x1))
mult_int(neg(x0), pos(x1))
mult_int(neg(x0), neg(x1))
mult_nat(0, x0)
mult_nat(s(x0), 0)
mult_nat(s(x0), s(x1))
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_int(pos(x0), pos(x1))
mod_int(pos(x0), neg(x1))
mod_int(neg(x0), pos(x1))
mod_int(neg(x0), neg(x1))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].
cond1(false, x0)
cond2(false, x0)
f(x0)
cond2(true, x0)
cond1(true, x0)
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
Q DP problem:
The TRS P consists of the following rules:
COND2(true, x[0]) → F(div_int(x[0], pos(s(s(0)))))
COND2(false, x[1]) → F(plus_int(pos(s(0)), mult_int(pos(s(s(s(0)))), x[1])))
COND1(true, x[2]) → COND2(equal_int(mod_int(x[2], pos(s(s(0)))), pos(0)), x[2])
F(x[3]) → COND1(greater_int(x[3], pos(s(0))), x[3])
The TRS R consists of the following rules:
mod_int(pos(x), pos(y)) → pos(mod_nat(x, y))
mod_int(neg(x), pos(y)) → neg(mod_nat(x, y))
equal_int(pos(0), pos(0)) → true
equal_int(neg(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
equal_int(neg(s(x)), pos(0)) → false
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
greater_int(pos(0), pos(s(y))) → false
greater_int(neg(0), pos(s(y))) → false
greater_int(neg(s(x)), pos(s(y))) → false
greater_int(pos(s(x)), pos(s(y))) → greater_int(pos(x), pos(y))
greater_int(pos(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
div_int(pos(x), pos(s(y))) → pos(div_nat(x, s(y)))
div_int(neg(x), pos(s(y))) → neg(div_nat(x, s(y)))
div_nat(0, s(y)) → 0
div_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), div_nat(minus_nat_s(x, y), s(y)), 0)
mult_int(pos(x), pos(y)) → pos(mult_nat(x, y))
mult_int(pos(x), neg(y)) → neg(mult_nat(x, y))
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
mult_nat(0, y) → 0
mult_nat(s(x), 0) → 0
mult_nat(s(x), s(y)) → plus_nat(mult_nat(x, s(y)), s(y))
The set Q consists of the following terms:
div_int(pos(x0), pos(s(x1)))
div_int(pos(x0), neg(s(x1)))
div_int(neg(x0), pos(s(x1)))
div_int(neg(x0), neg(s(x1)))
div_nat(0, s(x0))
div_nat(s(x0), s(x1))
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
mult_int(pos(x0), pos(x1))
mult_int(pos(x0), neg(x1))
mult_int(neg(x0), pos(x1))
mult_int(neg(x0), neg(x1))
mult_nat(0, x0)
mult_nat(s(x0), 0)
mult_nat(s(x0), s(x1))
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_int(pos(x0), pos(x1))
mod_int(pos(x0), neg(x1))
mod_int(neg(x0), pos(x1))
mod_int(neg(x0), neg(x1))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [LPAR04].
The following pairs can be oriented strictly and are deleted.
COND2(true, x[0]) → F(div_int(x[0], pos(s(s(0)))))
The remaining pairs can at least be oriented weakly.
COND2(false, x[1]) → F(plus_int(pos(s(0)), mult_int(pos(s(s(s(0)))), x[1])))
COND1(true, x[2]) → COND2(equal_int(mod_int(x[2], pos(s(s(0)))), pos(0)), x[2])
F(x[3]) → COND1(greater_int(x[3], pos(s(0))), x[3])
Used ordering: Matrix interpretation [MATRO] with arctic natural numbers [ARCTIC]:
| POL(COND2(x1, x2)) = | | · | x1 | + | | + | | · | x2 |
| POL(div_int(x1, x2)) = | | · | x1 | + | | + | | · | x2 |
| POL(plus_int(x1, x2)) = | | · | x1 | + | | + | | · | x2 |
| POL(mult_int(x1, x2)) = | | · | x1 | + | | + | | · | x2 |
| POL(COND1(x1, x2)) = | | · | x1 | + | | + | | · | x2 |
| POL(equal_int(x1, x2)) = | | · | x1 | + | | + | | · | x2 |
| POL(mod_int(x1, x2)) = | | · | x1 | + | | + | | · | x2 |
| POL(greater_int(x1, x2)) = | | · | x1 | + | | + | | · | x2 |
| POL(mult_nat(x1, x2)) = | | · | x1 | + | | + | | · | x2 |
| POL(plus_nat(x1, x2)) = | | · | x1 | + | | + | | · | x2 |
| POL(div_nat(x1, x2)) = | | · | x1 | + | | + | | · | x2 |
| POL(if(x1, x2, x3)) = | | · | x1 | + | | + | | · | x2 | + | | · | x3 |
| POL(greatereq_int(x1, x2)) = | | · | x1 | + | | + | | · | x2 |
| POL(minus_nat_s(x1, x2)) = | | · | x1 | + | | + | | · | x2 |
| POL(minus_nat(x1, x2)) = | | · | x1 | + | | + | | · | x2 |
| POL(mod_nat(x1, x2)) = | | · | x1 | + | | + | | · | x2 |
The following usable rules [FROCOS05] were oriented:
mult_nat(s(x), s(y)) → plus_nat(mult_nat(x, s(y)), s(y))
div_nat(0, s(y)) → 0
div_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), div_nat(minus_nat_s(x, y), s(y)), 0)
div_int(pos(x), pos(s(y))) → pos(div_nat(x, s(y)))
div_int(neg(x), pos(s(y))) → neg(div_nat(x, s(y)))
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
mult_int(pos(x), pos(y)) → pos(mult_nat(x, y))
mult_int(pos(x), neg(y)) → neg(mult_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
mult_nat(0, y) → 0
mult_nat(s(x), 0) → 0
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
equal_int(neg(s(x)), pos(0)) → false
equal_int(pos(s(x)), pos(0)) → false
equal_int(neg(0), pos(0)) → true
equal_int(pos(0), pos(0)) → true
mod_int(neg(x), pos(y)) → neg(mod_nat(x, y))
mod_int(pos(x), pos(y)) → pos(mod_nat(x, y))
greater_int(pos(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
greater_int(neg(s(x)), pos(s(y))) → false
greater_int(pos(s(x)), pos(s(y))) → greater_int(pos(x), pos(y))
greater_int(pos(0), pos(s(y))) → false
greater_int(neg(0), pos(s(y))) → false
if(true, x, y) → x
if(false, x, y) → y
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
COND2(false, x[1]) → F(plus_int(pos(s(0)), mult_int(pos(s(s(s(0)))), x[1])))
COND1(true, x[2]) → COND2(equal_int(mod_int(x[2], pos(s(s(0)))), pos(0)), x[2])
F(x[3]) → COND1(greater_int(x[3], pos(s(0))), x[3])
The TRS R consists of the following rules:
mod_int(pos(x), pos(y)) → pos(mod_nat(x, y))
mod_int(neg(x), pos(y)) → neg(mod_nat(x, y))
equal_int(pos(0), pos(0)) → true
equal_int(neg(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
equal_int(neg(s(x)), pos(0)) → false
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
greater_int(pos(0), pos(s(y))) → false
greater_int(neg(0), pos(s(y))) → false
greater_int(neg(s(x)), pos(s(y))) → false
greater_int(pos(s(x)), pos(s(y))) → greater_int(pos(x), pos(y))
greater_int(pos(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
div_int(pos(x), pos(s(y))) → pos(div_nat(x, s(y)))
div_int(neg(x), pos(s(y))) → neg(div_nat(x, s(y)))
div_nat(0, s(y)) → 0
div_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), div_nat(minus_nat_s(x, y), s(y)), 0)
mult_int(pos(x), pos(y)) → pos(mult_nat(x, y))
mult_int(pos(x), neg(y)) → neg(mult_nat(x, y))
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
mult_nat(0, y) → 0
mult_nat(s(x), 0) → 0
mult_nat(s(x), s(y)) → plus_nat(mult_nat(x, s(y)), s(y))
The set Q consists of the following terms:
div_int(pos(x0), pos(s(x1)))
div_int(pos(x0), neg(s(x1)))
div_int(neg(x0), pos(s(x1)))
div_int(neg(x0), neg(s(x1)))
div_nat(0, s(x0))
div_nat(s(x0), s(x1))
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
mult_int(pos(x0), pos(x1))
mult_int(pos(x0), neg(x1))
mult_int(neg(x0), pos(x1))
mult_int(neg(x0), neg(x1))
mult_nat(0, x0)
mult_nat(s(x0), 0)
mult_nat(s(x0), s(x1))
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_int(pos(x0), pos(x1))
mod_int(pos(x0), neg(x1))
mod_int(neg(x0), pos(x1))
mod_int(neg(x0), neg(x1))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
Q DP problem:
The TRS P consists of the following rules:
COND2(false, x[1]) → F(plus_int(pos(s(0)), mult_int(pos(s(s(s(0)))), x[1])))
COND1(true, x[2]) → COND2(equal_int(mod_int(x[2], pos(s(s(0)))), pos(0)), x[2])
F(x[3]) → COND1(greater_int(x[3], pos(s(0))), x[3])
The TRS R consists of the following rules:
greater_int(pos(0), pos(s(y))) → false
greater_int(neg(0), pos(s(y))) → false
greater_int(neg(s(x)), pos(s(y))) → false
greater_int(pos(s(x)), pos(s(y))) → greater_int(pos(x), pos(y))
greater_int(pos(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
mult_int(pos(x), pos(y)) → pos(mult_nat(x, y))
mult_int(pos(x), neg(y)) → neg(mult_nat(x, y))
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
mult_nat(0, y) → 0
mult_nat(s(x), 0) → 0
mult_nat(s(x), s(y)) → plus_nat(mult_nat(x, s(y)), s(y))
mod_int(pos(x), pos(y)) → pos(mod_nat(x, y))
mod_int(neg(x), pos(y)) → neg(mod_nat(x, y))
equal_int(pos(0), pos(0)) → true
equal_int(neg(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
equal_int(neg(s(x)), pos(0)) → false
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
The set Q consists of the following terms:
div_int(pos(x0), pos(s(x1)))
div_int(pos(x0), neg(s(x1)))
div_int(neg(x0), pos(s(x1)))
div_int(neg(x0), neg(s(x1)))
div_nat(0, s(x0))
div_nat(s(x0), s(x1))
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
mult_int(pos(x0), pos(x1))
mult_int(pos(x0), neg(x1))
mult_int(neg(x0), pos(x1))
mult_int(neg(x0), neg(x1))
mult_nat(0, x0)
mult_nat(s(x0), 0)
mult_nat(s(x0), s(x1))
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_int(pos(x0), pos(x1))
mod_int(pos(x0), neg(x1))
mod_int(neg(x0), pos(x1))
mod_int(neg(x0), neg(x1))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].
div_int(pos(x0), pos(s(x1)))
div_int(pos(x0), neg(s(x1)))
div_int(neg(x0), pos(s(x1)))
div_int(neg(x0), neg(s(x1)))
div_nat(0, s(x0))
div_nat(s(x0), s(x1))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ RemovalProof
↳ RemovalProof
↳ Narrowing
Q DP problem:
The TRS P consists of the following rules:
COND2(false, x[1]) → F(plus_int(pos(s(0)), mult_int(pos(s(s(s(0)))), x[1])))
COND1(true, x[2]) → COND2(equal_int(mod_int(x[2], pos(s(s(0)))), pos(0)), x[2])
F(x[3]) → COND1(greater_int(x[3], pos(s(0))), x[3])
The TRS R consists of the following rules:
greater_int(pos(0), pos(s(y))) → false
greater_int(neg(0), pos(s(y))) → false
greater_int(neg(s(x)), pos(s(y))) → false
greater_int(pos(s(x)), pos(s(y))) → greater_int(pos(x), pos(y))
greater_int(pos(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
mult_int(pos(x), pos(y)) → pos(mult_nat(x, y))
mult_int(pos(x), neg(y)) → neg(mult_nat(x, y))
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
mult_nat(0, y) → 0
mult_nat(s(x), 0) → 0
mult_nat(s(x), s(y)) → plus_nat(mult_nat(x, s(y)), s(y))
mod_int(pos(x), pos(y)) → pos(mod_nat(x, y))
mod_int(neg(x), pos(y)) → neg(mod_nat(x, y))
equal_int(pos(0), pos(0)) → true
equal_int(neg(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
equal_int(neg(s(x)), pos(0)) → false
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
The set Q consists of the following terms:
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
mult_int(pos(x0), pos(x1))
mult_int(pos(x0), neg(x1))
mult_int(neg(x0), pos(x1))
mult_int(neg(x0), neg(x1))
mult_nat(0, x0)
mult_nat(s(x0), 0)
mult_nat(s(x0), s(x1))
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_int(pos(x0), pos(x1))
mod_int(pos(x0), neg(x1))
mod_int(neg(x0), pos(x1))
mod_int(neg(x0), neg(x1))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
In the following pairs the term without variables pos(s(s(s(0)))) is replaced by the fresh variable x_removed.
Pair: COND2(false, x[1]) → F(plus_int(pos(s(0)), mult_int(pos(s(s(s(0)))), x[1])))
Positions in right side of the pair: The new variable was added to all pairs as a new argument[CONREM].
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ RemovalProof
↳ QDP
↳ RemovalProof
↳ Narrowing
Q DP problem:
The TRS P consists of the following rules:
COND2(false, x[1], x_removed) → F(plus_int(pos(s(0)), mult_int(x_removed, x[1])), x_removed)
F(x[3], x_removed) → COND1(greater_int(x[3], pos(s(0))), x[3], x_removed)
COND1(true, x[2], x_removed) → COND2(equal_int(mod_int(x[2], pos(s(s(0)))), pos(0)), x[2], x_removed)
The TRS R consists of the following rules:
greater_int(pos(0), pos(s(y))) → false
greater_int(neg(0), pos(s(y))) → false
greater_int(neg(s(x)), pos(s(y))) → false
greater_int(pos(s(x)), pos(s(y))) → greater_int(pos(x), pos(y))
greater_int(pos(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
mult_int(pos(x), pos(y)) → pos(mult_nat(x, y))
mult_int(pos(x), neg(y)) → neg(mult_nat(x, y))
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
mult_nat(0, y) → 0
mult_nat(s(x), 0) → 0
mult_nat(s(x), s(y)) → plus_nat(mult_nat(x, s(y)), s(y))
mod_int(pos(x), pos(y)) → pos(mod_nat(x, y))
mod_int(neg(x), pos(y)) → neg(mod_nat(x, y))
equal_int(pos(0), pos(0)) → true
equal_int(neg(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
equal_int(neg(s(x)), pos(0)) → false
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
The set Q consists of the following terms:
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
mult_int(pos(x0), pos(x1))
mult_int(pos(x0), neg(x1))
mult_int(neg(x0), pos(x1))
mult_int(neg(x0), neg(x1))
mult_nat(0, x0)
mult_nat(s(x0), 0)
mult_nat(s(x0), s(x1))
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_int(pos(x0), pos(x1))
mod_int(pos(x0), neg(x1))
mod_int(neg(x0), pos(x1))
mod_int(neg(x0), neg(x1))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
In the following pairs the term without variables pos(s(s(s(0)))) is replaced by the fresh variable x_removed.
Pair: COND2(false, x[1]) → F(plus_int(pos(s(0)), mult_int(pos(s(s(s(0)))), x[1])))
Positions in right side of the pair: The new variable was added to all pairs as a new argument[CONREM].
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ RemovalProof
↳ RemovalProof
↳ QDP
↳ Narrowing
Q DP problem:
The TRS P consists of the following rules:
COND2(false, x[1], x_removed) → F(plus_int(pos(s(0)), mult_int(x_removed, x[1])), x_removed)
F(x[3], x_removed) → COND1(greater_int(x[3], pos(s(0))), x[3], x_removed)
COND1(true, x[2], x_removed) → COND2(equal_int(mod_int(x[2], pos(s(s(0)))), pos(0)), x[2], x_removed)
The TRS R consists of the following rules:
greater_int(pos(0), pos(s(y))) → false
greater_int(neg(0), pos(s(y))) → false
greater_int(neg(s(x)), pos(s(y))) → false
greater_int(pos(s(x)), pos(s(y))) → greater_int(pos(x), pos(y))
greater_int(pos(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
mult_int(pos(x), pos(y)) → pos(mult_nat(x, y))
mult_int(pos(x), neg(y)) → neg(mult_nat(x, y))
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
mult_nat(0, y) → 0
mult_nat(s(x), 0) → 0
mult_nat(s(x), s(y)) → plus_nat(mult_nat(x, s(y)), s(y))
mod_int(pos(x), pos(y)) → pos(mod_nat(x, y))
mod_int(neg(x), pos(y)) → neg(mod_nat(x, y))
equal_int(pos(0), pos(0)) → true
equal_int(neg(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
equal_int(neg(s(x)), pos(0)) → false
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
The set Q consists of the following terms:
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
mult_int(pos(x0), pos(x1))
mult_int(pos(x0), neg(x1))
mult_int(neg(x0), pos(x1))
mult_int(neg(x0), neg(x1))
mult_nat(0, x0)
mult_nat(s(x0), 0)
mult_nat(s(x0), s(x1))
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_int(pos(x0), pos(x1))
mod_int(pos(x0), neg(x1))
mod_int(neg(x0), pos(x1))
mod_int(neg(x0), neg(x1))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
By narrowing [LPAR04] the rule COND1(true, x[2]) → COND2(equal_int(mod_int(x[2], pos(s(s(0)))), pos(0)), x[2]) at position [0] we obtained the following new rules [LPAR04]:
COND1(true, pos(x0)) → COND2(equal_int(pos(mod_nat(x0, s(s(0)))), pos(0)), pos(x0))
COND1(true, neg(x0)) → COND2(equal_int(neg(mod_nat(x0, s(s(0)))), pos(0)), neg(x0))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ RemovalProof
↳ RemovalProof
↳ Narrowing
↳ QDP
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
COND2(false, x[1]) → F(plus_int(pos(s(0)), mult_int(pos(s(s(s(0)))), x[1])))
F(x[3]) → COND1(greater_int(x[3], pos(s(0))), x[3])
COND1(true, pos(x0)) → COND2(equal_int(pos(mod_nat(x0, s(s(0)))), pos(0)), pos(x0))
COND1(true, neg(x0)) → COND2(equal_int(neg(mod_nat(x0, s(s(0)))), pos(0)), neg(x0))
The TRS R consists of the following rules:
greater_int(pos(0), pos(s(y))) → false
greater_int(neg(0), pos(s(y))) → false
greater_int(neg(s(x)), pos(s(y))) → false
greater_int(pos(s(x)), pos(s(y))) → greater_int(pos(x), pos(y))
greater_int(pos(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
mult_int(pos(x), pos(y)) → pos(mult_nat(x, y))
mult_int(pos(x), neg(y)) → neg(mult_nat(x, y))
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
mult_nat(0, y) → 0
mult_nat(s(x), 0) → 0
mult_nat(s(x), s(y)) → plus_nat(mult_nat(x, s(y)), s(y))
mod_int(pos(x), pos(y)) → pos(mod_nat(x, y))
mod_int(neg(x), pos(y)) → neg(mod_nat(x, y))
equal_int(pos(0), pos(0)) → true
equal_int(neg(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
equal_int(neg(s(x)), pos(0)) → false
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
The set Q consists of the following terms:
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
mult_int(pos(x0), pos(x1))
mult_int(pos(x0), neg(x1))
mult_int(neg(x0), pos(x1))
mult_int(neg(x0), neg(x1))
mult_nat(0, x0)
mult_nat(s(x0), 0)
mult_nat(s(x0), s(x1))
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_int(pos(x0), pos(x1))
mod_int(pos(x0), neg(x1))
mod_int(neg(x0), pos(x1))
mod_int(neg(x0), neg(x1))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ RemovalProof
↳ RemovalProof
↳ Narrowing
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
Q DP problem:
The TRS P consists of the following rules:
COND2(false, x[1]) → F(plus_int(pos(s(0)), mult_int(pos(s(s(s(0)))), x[1])))
F(x[3]) → COND1(greater_int(x[3], pos(s(0))), x[3])
COND1(true, pos(x0)) → COND2(equal_int(pos(mod_nat(x0, s(s(0)))), pos(0)), pos(x0))
COND1(true, neg(x0)) → COND2(equal_int(neg(mod_nat(x0, s(s(0)))), pos(0)), neg(x0))
The TRS R consists of the following rules:
mult_int(pos(x), pos(y)) → pos(mult_nat(x, y))
mult_int(pos(x), neg(y)) → neg(mult_nat(x, y))
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
mult_nat(0, y) → 0
mult_nat(s(x), 0) → 0
mult_nat(s(x), s(y)) → plus_nat(mult_nat(x, s(y)), s(y))
greater_int(pos(0), pos(s(y))) → false
greater_int(neg(0), pos(s(y))) → false
greater_int(neg(s(x)), pos(s(y))) → false
greater_int(pos(s(x)), pos(s(y))) → greater_int(pos(x), pos(y))
greater_int(pos(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
equal_int(neg(0), pos(0)) → true
equal_int(neg(s(x)), pos(0)) → false
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
equal_int(pos(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
The set Q consists of the following terms:
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
mult_int(pos(x0), pos(x1))
mult_int(pos(x0), neg(x1))
mult_int(neg(x0), pos(x1))
mult_int(neg(x0), neg(x1))
mult_nat(0, x0)
mult_nat(s(x0), 0)
mult_nat(s(x0), s(x1))
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_int(pos(x0), pos(x1))
mod_int(pos(x0), neg(x1))
mod_int(neg(x0), pos(x1))
mod_int(neg(x0), neg(x1))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].
mod_int(pos(x0), pos(x1))
mod_int(pos(x0), neg(x1))
mod_int(neg(x0), pos(x1))
mod_int(neg(x0), neg(x1))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ RemovalProof
↳ RemovalProof
↳ Narrowing
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
Q DP problem:
The TRS P consists of the following rules:
COND2(false, x[1]) → F(plus_int(pos(s(0)), mult_int(pos(s(s(s(0)))), x[1])))
F(x[3]) → COND1(greater_int(x[3], pos(s(0))), x[3])
COND1(true, pos(x0)) → COND2(equal_int(pos(mod_nat(x0, s(s(0)))), pos(0)), pos(x0))
COND1(true, neg(x0)) → COND2(equal_int(neg(mod_nat(x0, s(s(0)))), pos(0)), neg(x0))
The TRS R consists of the following rules:
mult_int(pos(x), pos(y)) → pos(mult_nat(x, y))
mult_int(pos(x), neg(y)) → neg(mult_nat(x, y))
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
mult_nat(0, y) → 0
mult_nat(s(x), 0) → 0
mult_nat(s(x), s(y)) → plus_nat(mult_nat(x, s(y)), s(y))
greater_int(pos(0), pos(s(y))) → false
greater_int(neg(0), pos(s(y))) → false
greater_int(neg(s(x)), pos(s(y))) → false
greater_int(pos(s(x)), pos(s(y))) → greater_int(pos(x), pos(y))
greater_int(pos(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
equal_int(neg(0), pos(0)) → true
equal_int(neg(s(x)), pos(0)) → false
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
equal_int(pos(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
The set Q consists of the following terms:
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
mult_int(pos(x0), pos(x1))
mult_int(pos(x0), neg(x1))
mult_int(neg(x0), pos(x1))
mult_int(neg(x0), neg(x1))
mult_nat(0, x0)
mult_nat(s(x0), 0)
mult_nat(s(x0), s(x1))
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
By narrowing [LPAR04] the rule F(x[3]) → COND1(greater_int(x[3], pos(s(0))), x[3]) at position [0] we obtained the following new rules [LPAR04]:
F(neg(0)) → COND1(false, neg(0))
F(pos(0)) → COND1(false, pos(0))
F(neg(s(x0))) → COND1(false, neg(s(x0)))
F(pos(s(x0))) → COND1(greater_int(pos(x0), pos(0)), pos(s(x0)))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ RemovalProof
↳ RemovalProof
↳ Narrowing
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
Q DP problem:
The TRS P consists of the following rules:
COND2(false, x[1]) → F(plus_int(pos(s(0)), mult_int(pos(s(s(s(0)))), x[1])))
COND1(true, pos(x0)) → COND2(equal_int(pos(mod_nat(x0, s(s(0)))), pos(0)), pos(x0))
COND1(true, neg(x0)) → COND2(equal_int(neg(mod_nat(x0, s(s(0)))), pos(0)), neg(x0))
F(neg(0)) → COND1(false, neg(0))
F(pos(0)) → COND1(false, pos(0))
F(neg(s(x0))) → COND1(false, neg(s(x0)))
F(pos(s(x0))) → COND1(greater_int(pos(x0), pos(0)), pos(s(x0)))
The TRS R consists of the following rules:
mult_int(pos(x), pos(y)) → pos(mult_nat(x, y))
mult_int(pos(x), neg(y)) → neg(mult_nat(x, y))
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
mult_nat(0, y) → 0
mult_nat(s(x), 0) → 0
mult_nat(s(x), s(y)) → plus_nat(mult_nat(x, s(y)), s(y))
greater_int(pos(0), pos(s(y))) → false
greater_int(neg(0), pos(s(y))) → false
greater_int(neg(s(x)), pos(s(y))) → false
greater_int(pos(s(x)), pos(s(y))) → greater_int(pos(x), pos(y))
greater_int(pos(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
equal_int(neg(0), pos(0)) → true
equal_int(neg(s(x)), pos(0)) → false
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
equal_int(pos(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
The set Q consists of the following terms:
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
mult_int(pos(x0), pos(x1))
mult_int(pos(x0), neg(x1))
mult_int(neg(x0), pos(x1))
mult_int(neg(x0), neg(x1))
mult_nat(0, x0)
mult_nat(s(x0), 0)
mult_nat(s(x0), s(x1))
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 4 less nodes.
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ RemovalProof
↳ RemovalProof
↳ Narrowing
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
F(pos(s(x0))) → COND1(greater_int(pos(x0), pos(0)), pos(s(x0)))
COND1(true, pos(x0)) → COND2(equal_int(pos(mod_nat(x0, s(s(0)))), pos(0)), pos(x0))
COND2(false, x[1]) → F(plus_int(pos(s(0)), mult_int(pos(s(s(s(0)))), x[1])))
The TRS R consists of the following rules:
mult_int(pos(x), pos(y)) → pos(mult_nat(x, y))
mult_int(pos(x), neg(y)) → neg(mult_nat(x, y))
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
mult_nat(0, y) → 0
mult_nat(s(x), 0) → 0
mult_nat(s(x), s(y)) → plus_nat(mult_nat(x, s(y)), s(y))
greater_int(pos(0), pos(s(y))) → false
greater_int(neg(0), pos(s(y))) → false
greater_int(neg(s(x)), pos(s(y))) → false
greater_int(pos(s(x)), pos(s(y))) → greater_int(pos(x), pos(y))
greater_int(pos(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
equal_int(neg(0), pos(0)) → true
equal_int(neg(s(x)), pos(0)) → false
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
equal_int(pos(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
The set Q consists of the following terms:
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
mult_int(pos(x0), pos(x1))
mult_int(pos(x0), neg(x1))
mult_int(neg(x0), pos(x1))
mult_int(neg(x0), neg(x1))
mult_nat(0, x0)
mult_nat(s(x0), 0)
mult_nat(s(x0), s(x1))
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ RemovalProof
↳ RemovalProof
↳ Narrowing
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
Q DP problem:
The TRS P consists of the following rules:
F(pos(s(x0))) → COND1(greater_int(pos(x0), pos(0)), pos(s(x0)))
COND1(true, pos(x0)) → COND2(equal_int(pos(mod_nat(x0, s(s(0)))), pos(0)), pos(x0))
COND2(false, x[1]) → F(plus_int(pos(s(0)), mult_int(pos(s(s(s(0)))), x[1])))
The TRS R consists of the following rules:
greater_int(pos(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
equal_int(pos(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
mult_int(pos(x), pos(y)) → pos(mult_nat(x, y))
mult_int(pos(x), neg(y)) → neg(mult_nat(x, y))
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
mult_nat(0, y) → 0
mult_nat(s(x), 0) → 0
mult_nat(s(x), s(y)) → plus_nat(mult_nat(x, s(y)), s(y))
The set Q consists of the following terms:
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
mult_int(pos(x0), pos(x1))
mult_int(pos(x0), neg(x1))
mult_int(neg(x0), pos(x1))
mult_int(neg(x0), neg(x1))
mult_nat(0, x0)
mult_nat(s(x0), 0)
mult_nat(s(x0), s(x1))
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
By narrowing [LPAR04] the rule F(pos(s(x0))) → COND1(greater_int(pos(x0), pos(0)), pos(s(x0))) at position [0] we obtained the following new rules [LPAR04]:
F(pos(s(s(x0)))) → COND1(true, pos(s(s(x0))))
F(pos(s(0))) → COND1(false, pos(s(0)))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ RemovalProof
↳ RemovalProof
↳ Narrowing
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
Q DP problem:
The TRS P consists of the following rules:
COND1(true, pos(x0)) → COND2(equal_int(pos(mod_nat(x0, s(s(0)))), pos(0)), pos(x0))
COND2(false, x[1]) → F(plus_int(pos(s(0)), mult_int(pos(s(s(s(0)))), x[1])))
F(pos(s(s(x0)))) → COND1(true, pos(s(s(x0))))
F(pos(s(0))) → COND1(false, pos(s(0)))
The TRS R consists of the following rules:
greater_int(pos(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
equal_int(pos(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
mult_int(pos(x), pos(y)) → pos(mult_nat(x, y))
mult_int(pos(x), neg(y)) → neg(mult_nat(x, y))
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
mult_nat(0, y) → 0
mult_nat(s(x), 0) → 0
mult_nat(s(x), s(y)) → plus_nat(mult_nat(x, s(y)), s(y))
The set Q consists of the following terms:
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
mult_int(pos(x0), pos(x1))
mult_int(pos(x0), neg(x1))
mult_int(neg(x0), pos(x1))
mult_int(neg(x0), neg(x1))
mult_nat(0, x0)
mult_nat(s(x0), 0)
mult_nat(s(x0), s(x1))
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ RemovalProof
↳ RemovalProof
↳ Narrowing
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
COND2(false, x[1]) → F(plus_int(pos(s(0)), mult_int(pos(s(s(s(0)))), x[1])))
F(pos(s(s(x0)))) → COND1(true, pos(s(s(x0))))
COND1(true, pos(x0)) → COND2(equal_int(pos(mod_nat(x0, s(s(0)))), pos(0)), pos(x0))
The TRS R consists of the following rules:
greater_int(pos(0), pos(0)) → false
greater_int(pos(s(x)), pos(0)) → true
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
equal_int(pos(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
mult_int(pos(x), pos(y)) → pos(mult_nat(x, y))
mult_int(pos(x), neg(y)) → neg(mult_nat(x, y))
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
mult_nat(0, y) → 0
mult_nat(s(x), 0) → 0
mult_nat(s(x), s(y)) → plus_nat(mult_nat(x, s(y)), s(y))
The set Q consists of the following terms:
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
mult_int(pos(x0), pos(x1))
mult_int(pos(x0), neg(x1))
mult_int(neg(x0), pos(x1))
mult_int(neg(x0), neg(x1))
mult_nat(0, x0)
mult_nat(s(x0), 0)
mult_nat(s(x0), s(x1))
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ RemovalProof
↳ RemovalProof
↳ Narrowing
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
Q DP problem:
The TRS P consists of the following rules:
COND2(false, x[1]) → F(plus_int(pos(s(0)), mult_int(pos(s(s(s(0)))), x[1])))
F(pos(s(s(x0)))) → COND1(true, pos(s(s(x0))))
COND1(true, pos(x0)) → COND2(equal_int(pos(mod_nat(x0, s(s(0)))), pos(0)), pos(x0))
The TRS R consists of the following rules:
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
equal_int(pos(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
mult_int(pos(x), pos(y)) → pos(mult_nat(x, y))
mult_int(pos(x), neg(y)) → neg(mult_nat(x, y))
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
mult_nat(0, y) → 0
mult_nat(s(x), 0) → 0
mult_nat(s(x), s(y)) → plus_nat(mult_nat(x, s(y)), s(y))
The set Q consists of the following terms:
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
mult_int(pos(x0), pos(x1))
mult_int(pos(x0), neg(x1))
mult_int(neg(x0), pos(x1))
mult_int(neg(x0), neg(x1))
mult_nat(0, x0)
mult_nat(s(x0), 0)
mult_nat(s(x0), s(x1))
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].
greater_int(pos(0), pos(0))
greater_int(pos(0), neg(0))
greater_int(neg(0), pos(0))
greater_int(neg(0), neg(0))
greater_int(pos(0), pos(s(x0)))
greater_int(neg(0), pos(s(x0)))
greater_int(pos(0), neg(s(x0)))
greater_int(neg(0), neg(s(x0)))
greater_int(pos(s(x0)), pos(0))
greater_int(neg(s(x0)), pos(0))
greater_int(pos(s(x0)), neg(0))
greater_int(neg(s(x0)), neg(0))
greater_int(pos(s(x0)), neg(s(x1)))
greater_int(neg(s(x0)), pos(s(x1)))
greater_int(pos(s(x0)), pos(s(x1)))
greater_int(neg(s(x0)), neg(s(x1)))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ RemovalProof
↳ RemovalProof
↳ Narrowing
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
Q DP problem:
The TRS P consists of the following rules:
COND2(false, x[1]) → F(plus_int(pos(s(0)), mult_int(pos(s(s(s(0)))), x[1])))
F(pos(s(s(x0)))) → COND1(true, pos(s(s(x0))))
COND1(true, pos(x0)) → COND2(equal_int(pos(mod_nat(x0, s(s(0)))), pos(0)), pos(x0))
The TRS R consists of the following rules:
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
equal_int(pos(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
mult_int(pos(x), pos(y)) → pos(mult_nat(x, y))
mult_int(pos(x), neg(y)) → neg(mult_nat(x, y))
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
mult_nat(0, y) → 0
mult_nat(s(x), 0) → 0
mult_nat(s(x), s(y)) → plus_nat(mult_nat(x, s(y)), s(y))
The set Q consists of the following terms:
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
mult_int(pos(x0), pos(x1))
mult_int(pos(x0), neg(x1))
mult_int(neg(x0), pos(x1))
mult_int(neg(x0), neg(x1))
mult_nat(0, x0)
mult_nat(s(x0), 0)
mult_nat(s(x0), s(x1))
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By narrowing [LPAR04] the rule COND2(false, x[1]) → F(plus_int(pos(s(0)), mult_int(pos(s(s(s(0)))), x[1]))) at position [0] we obtained the following new rules [LPAR04]:
COND2(false, pos(x1)) → F(plus_int(pos(s(0)), pos(mult_nat(s(s(s(0))), x1))))
COND2(false, neg(x1)) → F(plus_int(pos(s(0)), neg(mult_nat(s(s(s(0))), x1))))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ RemovalProof
↳ RemovalProof
↳ Narrowing
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
Q DP problem:
The TRS P consists of the following rules:
F(pos(s(s(x0)))) → COND1(true, pos(s(s(x0))))
COND1(true, pos(x0)) → COND2(equal_int(pos(mod_nat(x0, s(s(0)))), pos(0)), pos(x0))
COND2(false, pos(x1)) → F(plus_int(pos(s(0)), pos(mult_nat(s(s(s(0))), x1))))
COND2(false, neg(x1)) → F(plus_int(pos(s(0)), neg(mult_nat(s(s(s(0))), x1))))
The TRS R consists of the following rules:
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
equal_int(pos(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
mult_int(pos(x), pos(y)) → pos(mult_nat(x, y))
mult_int(pos(x), neg(y)) → neg(mult_nat(x, y))
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
mult_nat(0, y) → 0
mult_nat(s(x), 0) → 0
mult_nat(s(x), s(y)) → plus_nat(mult_nat(x, s(y)), s(y))
The set Q consists of the following terms:
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
mult_int(pos(x0), pos(x1))
mult_int(pos(x0), neg(x1))
mult_int(neg(x0), pos(x1))
mult_int(neg(x0), neg(x1))
mult_nat(0, x0)
mult_nat(s(x0), 0)
mult_nat(s(x0), s(x1))
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ RemovalProof
↳ RemovalProof
↳ Narrowing
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
COND1(true, pos(x0)) → COND2(equal_int(pos(mod_nat(x0, s(s(0)))), pos(0)), pos(x0))
COND2(false, pos(x1)) → F(plus_int(pos(s(0)), pos(mult_nat(s(s(s(0))), x1))))
F(pos(s(s(x0)))) → COND1(true, pos(s(s(x0))))
The TRS R consists of the following rules:
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
equal_int(pos(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
mult_int(pos(x), pos(y)) → pos(mult_nat(x, y))
mult_int(pos(x), neg(y)) → neg(mult_nat(x, y))
plus_int(pos(x), neg(y)) → minus_nat(x, y)
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
minus_nat(0, 0) → pos(0)
minus_nat(0, s(y)) → neg(s(y))
minus_nat(s(x), 0) → pos(s(x))
minus_nat(s(x), s(y)) → minus_nat(x, y)
mult_nat(0, y) → 0
mult_nat(s(x), 0) → 0
mult_nat(s(x), s(y)) → plus_nat(mult_nat(x, s(y)), s(y))
The set Q consists of the following terms:
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
mult_int(pos(x0), pos(x1))
mult_int(pos(x0), neg(x1))
mult_int(neg(x0), pos(x1))
mult_int(neg(x0), neg(x1))
mult_nat(0, x0)
mult_nat(s(x0), 0)
mult_nat(s(x0), s(x1))
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ RemovalProof
↳ RemovalProof
↳ Narrowing
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
Q DP problem:
The TRS P consists of the following rules:
COND1(true, pos(x0)) → COND2(equal_int(pos(mod_nat(x0, s(s(0)))), pos(0)), pos(x0))
COND2(false, pos(x1)) → F(plus_int(pos(s(0)), pos(mult_nat(s(s(s(0))), x1))))
F(pos(s(s(x0)))) → COND1(true, pos(s(s(x0))))
The TRS R consists of the following rules:
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
equal_int(pos(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
mult_nat(s(x), 0) → 0
mult_nat(s(x), s(y)) → plus_nat(mult_nat(x, s(y)), s(y))
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
mult_nat(0, y) → 0
The set Q consists of the following terms:
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
mult_int(pos(x0), pos(x1))
mult_int(pos(x0), neg(x1))
mult_int(neg(x0), pos(x1))
mult_int(neg(x0), neg(x1))
mult_nat(0, x0)
mult_nat(s(x0), 0)
mult_nat(s(x0), s(x1))
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].
minus_nat(0, 0)
minus_nat(0, s(x0))
minus_nat(s(x0), 0)
minus_nat(s(x0), s(x1))
mult_int(pos(x0), pos(x1))
mult_int(pos(x0), neg(x1))
mult_int(neg(x0), pos(x1))
mult_int(neg(x0), neg(x1))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ RemovalProof
↳ RemovalProof
↳ Narrowing
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
Q DP problem:
The TRS P consists of the following rules:
COND1(true, pos(x0)) → COND2(equal_int(pos(mod_nat(x0, s(s(0)))), pos(0)), pos(x0))
COND2(false, pos(x1)) → F(plus_int(pos(s(0)), pos(mult_nat(s(s(s(0))), x1))))
F(pos(s(s(x0)))) → COND1(true, pos(s(s(x0))))
The TRS R consists of the following rules:
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
equal_int(pos(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
mult_nat(s(x), 0) → 0
mult_nat(s(x), s(y)) → plus_nat(mult_nat(x, s(y)), s(y))
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
mult_nat(0, y) → 0
The set Q consists of the following terms:
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
mult_nat(0, x0)
mult_nat(s(x0), 0)
mult_nat(s(x0), s(x1))
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule COND2(false, pos(x1)) → F(plus_int(pos(s(0)), pos(mult_nat(s(s(s(0))), x1)))) at position [0] we obtained the following new rules [LPAR04]:
COND2(false, pos(x1)) → F(pos(plus_nat(s(0), mult_nat(s(s(s(0))), x1))))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ RemovalProof
↳ RemovalProof
↳ Narrowing
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
COND1(true, pos(x0)) → COND2(equal_int(pos(mod_nat(x0, s(s(0)))), pos(0)), pos(x0))
F(pos(s(s(x0)))) → COND1(true, pos(s(s(x0))))
COND2(false, pos(x1)) → F(pos(plus_nat(s(0), mult_nat(s(s(s(0))), x1))))
The TRS R consists of the following rules:
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
equal_int(pos(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
mult_nat(s(x), 0) → 0
mult_nat(s(x), s(y)) → plus_nat(mult_nat(x, s(y)), s(y))
plus_int(pos(x), pos(y)) → pos(plus_nat(x, y))
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
mult_nat(0, y) → 0
The set Q consists of the following terms:
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
mult_nat(0, x0)
mult_nat(s(x0), 0)
mult_nat(s(x0), s(x1))
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ RemovalProof
↳ RemovalProof
↳ Narrowing
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
Q DP problem:
The TRS P consists of the following rules:
COND1(true, pos(x0)) → COND2(equal_int(pos(mod_nat(x0, s(s(0)))), pos(0)), pos(x0))
F(pos(s(s(x0)))) → COND1(true, pos(s(s(x0))))
COND2(false, pos(x1)) → F(pos(plus_nat(s(0), mult_nat(s(s(s(0))), x1))))
The TRS R consists of the following rules:
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
equal_int(pos(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
mult_nat(s(x), 0) → 0
mult_nat(s(x), s(y)) → plus_nat(mult_nat(x, s(y)), s(y))
plus_nat(s(x), y) → s(plus_nat(x, y))
plus_nat(0, x) → x
mult_nat(0, y) → 0
The set Q consists of the following terms:
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
mult_nat(0, x0)
mult_nat(s(x0), 0)
mult_nat(s(x0), s(x1))
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].
plus_int(pos(x0), neg(x1))
plus_int(neg(x0), pos(x1))
plus_int(neg(x0), neg(x1))
plus_int(pos(x0), pos(x1))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ RemovalProof
↳ RemovalProof
↳ Narrowing
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
Q DP problem:
The TRS P consists of the following rules:
COND1(true, pos(x0)) → COND2(equal_int(pos(mod_nat(x0, s(s(0)))), pos(0)), pos(x0))
F(pos(s(s(x0)))) → COND1(true, pos(s(s(x0))))
COND2(false, pos(x1)) → F(pos(plus_nat(s(0), mult_nat(s(s(s(0))), x1))))
The TRS R consists of the following rules:
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
equal_int(pos(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
mult_nat(s(x), 0) → 0
mult_nat(s(x), s(y)) → plus_nat(mult_nat(x, s(y)), s(y))
plus_nat(s(x), y) → s(plus_nat(x, y))
plus_nat(0, x) → x
mult_nat(0, y) → 0
The set Q consists of the following terms:
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
mult_nat(0, x0)
mult_nat(s(x0), 0)
mult_nat(s(x0), s(x1))
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule COND2(false, pos(x1)) → F(pos(plus_nat(s(0), mult_nat(s(s(s(0))), x1)))) at position [0,0] we obtained the following new rules [LPAR04]:
COND2(false, pos(x1)) → F(pos(s(plus_nat(0, mult_nat(s(s(s(0))), x1)))))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ RemovalProof
↳ RemovalProof
↳ Narrowing
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
Q DP problem:
The TRS P consists of the following rules:
COND1(true, pos(x0)) → COND2(equal_int(pos(mod_nat(x0, s(s(0)))), pos(0)), pos(x0))
F(pos(s(s(x0)))) → COND1(true, pos(s(s(x0))))
COND2(false, pos(x1)) → F(pos(s(plus_nat(0, mult_nat(s(s(s(0))), x1)))))
The TRS R consists of the following rules:
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
equal_int(pos(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
mult_nat(s(x), 0) → 0
mult_nat(s(x), s(y)) → plus_nat(mult_nat(x, s(y)), s(y))
plus_nat(s(x), y) → s(plus_nat(x, y))
plus_nat(0, x) → x
mult_nat(0, y) → 0
The set Q consists of the following terms:
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
mult_nat(0, x0)
mult_nat(s(x0), 0)
mult_nat(s(x0), s(x1))
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule COND2(false, pos(x1)) → F(pos(s(plus_nat(0, mult_nat(s(s(s(0))), x1))))) at position [0,0,0] we obtained the following new rules [LPAR04]:
COND2(false, pos(x1)) → F(pos(s(mult_nat(s(s(s(0))), x1))))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ RemovalProof
↳ RemovalProof
↳ Narrowing
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
Q DP problem:
The TRS P consists of the following rules:
COND1(true, pos(x0)) → COND2(equal_int(pos(mod_nat(x0, s(s(0)))), pos(0)), pos(x0))
F(pos(s(s(x0)))) → COND1(true, pos(s(s(x0))))
COND2(false, pos(x1)) → F(pos(s(mult_nat(s(s(s(0))), x1))))
The TRS R consists of the following rules:
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
equal_int(pos(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
mult_nat(s(x), 0) → 0
mult_nat(s(x), s(y)) → plus_nat(mult_nat(x, s(y)), s(y))
plus_nat(s(x), y) → s(plus_nat(x, y))
plus_nat(0, x) → x
mult_nat(0, y) → 0
The set Q consists of the following terms:
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
mult_nat(0, x0)
mult_nat(s(x0), 0)
mult_nat(s(x0), s(x1))
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By instantiating [LPAR04] the rule COND1(true, pos(x0)) → COND2(equal_int(pos(mod_nat(x0, s(s(0)))), pos(0)), pos(x0)) we obtained the following new rules [LPAR04]:
COND1(true, pos(s(s(z0)))) → COND2(equal_int(pos(mod_nat(s(s(z0)), s(s(0)))), pos(0)), pos(s(s(z0))))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ RemovalProof
↳ RemovalProof
↳ Narrowing
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
Q DP problem:
The TRS P consists of the following rules:
F(pos(s(s(x0)))) → COND1(true, pos(s(s(x0))))
COND2(false, pos(x1)) → F(pos(s(mult_nat(s(s(s(0))), x1))))
COND1(true, pos(s(s(z0)))) → COND2(equal_int(pos(mod_nat(s(s(z0)), s(s(0)))), pos(0)), pos(s(s(z0))))
The TRS R consists of the following rules:
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
equal_int(pos(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
mult_nat(s(x), 0) → 0
mult_nat(s(x), s(y)) → plus_nat(mult_nat(x, s(y)), s(y))
plus_nat(s(x), y) → s(plus_nat(x, y))
plus_nat(0, x) → x
mult_nat(0, y) → 0
The set Q consists of the following terms:
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
mult_nat(0, x0)
mult_nat(s(x0), 0)
mult_nat(s(x0), s(x1))
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule COND1(true, pos(s(s(z0)))) → COND2(equal_int(pos(mod_nat(s(s(z0)), s(s(0)))), pos(0)), pos(s(s(z0)))) at position [0,0,0] we obtained the following new rules [LPAR04]:
COND1(true, pos(s(s(z0)))) → COND2(equal_int(pos(if(greatereq_int(pos(s(z0)), pos(s(0))), mod_nat(minus_nat_s(s(z0), s(0)), s(s(0))), s(s(z0)))), pos(0)), pos(s(s(z0))))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ RemovalProof
↳ RemovalProof
↳ Narrowing
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
Q DP problem:
The TRS P consists of the following rules:
F(pos(s(s(x0)))) → COND1(true, pos(s(s(x0))))
COND2(false, pos(x1)) → F(pos(s(mult_nat(s(s(s(0))), x1))))
COND1(true, pos(s(s(z0)))) → COND2(equal_int(pos(if(greatereq_int(pos(s(z0)), pos(s(0))), mod_nat(minus_nat_s(s(z0), s(0)), s(s(0))), s(s(z0)))), pos(0)), pos(s(s(z0))))
The TRS R consists of the following rules:
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
equal_int(pos(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
mult_nat(s(x), 0) → 0
mult_nat(s(x), s(y)) → plus_nat(mult_nat(x, s(y)), s(y))
plus_nat(s(x), y) → s(plus_nat(x, y))
plus_nat(0, x) → x
mult_nat(0, y) → 0
The set Q consists of the following terms:
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
mult_nat(0, x0)
mult_nat(s(x0), 0)
mult_nat(s(x0), s(x1))
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule COND1(true, pos(s(s(z0)))) → COND2(equal_int(pos(if(greatereq_int(pos(s(z0)), pos(s(0))), mod_nat(minus_nat_s(s(z0), s(0)), s(s(0))), s(s(z0)))), pos(0)), pos(s(s(z0)))) at position [0,0,0,0] we obtained the following new rules [LPAR04]:
COND1(true, pos(s(s(z0)))) → COND2(equal_int(pos(if(greatereq_int(pos(z0), pos(0)), mod_nat(minus_nat_s(s(z0), s(0)), s(s(0))), s(s(z0)))), pos(0)), pos(s(s(z0))))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ RemovalProof
↳ RemovalProof
↳ Narrowing
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
Q DP problem:
The TRS P consists of the following rules:
F(pos(s(s(x0)))) → COND1(true, pos(s(s(x0))))
COND2(false, pos(x1)) → F(pos(s(mult_nat(s(s(s(0))), x1))))
COND1(true, pos(s(s(z0)))) → COND2(equal_int(pos(if(greatereq_int(pos(z0), pos(0)), mod_nat(minus_nat_s(s(z0), s(0)), s(s(0))), s(s(z0)))), pos(0)), pos(s(s(z0))))
The TRS R consists of the following rules:
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
equal_int(pos(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
mult_nat(s(x), 0) → 0
mult_nat(s(x), s(y)) → plus_nat(mult_nat(x, s(y)), s(y))
plus_nat(s(x), y) → s(plus_nat(x, y))
plus_nat(0, x) → x
mult_nat(0, y) → 0
The set Q consists of the following terms:
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
mult_nat(0, x0)
mult_nat(s(x0), 0)
mult_nat(s(x0), s(x1))
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule COND1(true, pos(s(s(z0)))) → COND2(equal_int(pos(if(greatereq_int(pos(z0), pos(0)), mod_nat(minus_nat_s(s(z0), s(0)), s(s(0))), s(s(z0)))), pos(0)), pos(s(s(z0)))) at position [0,0,0,0] we obtained the following new rules [LPAR04]:
COND1(true, pos(s(s(z0)))) → COND2(equal_int(pos(if(true, mod_nat(minus_nat_s(s(z0), s(0)), s(s(0))), s(s(z0)))), pos(0)), pos(s(s(z0))))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ RemovalProof
↳ RemovalProof
↳ Narrowing
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
Q DP problem:
The TRS P consists of the following rules:
F(pos(s(s(x0)))) → COND1(true, pos(s(s(x0))))
COND2(false, pos(x1)) → F(pos(s(mult_nat(s(s(s(0))), x1))))
COND1(true, pos(s(s(z0)))) → COND2(equal_int(pos(if(true, mod_nat(minus_nat_s(s(z0), s(0)), s(s(0))), s(s(z0)))), pos(0)), pos(s(s(z0))))
The TRS R consists of the following rules:
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
equal_int(pos(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
mult_nat(s(x), 0) → 0
mult_nat(s(x), s(y)) → plus_nat(mult_nat(x, s(y)), s(y))
plus_nat(s(x), y) → s(plus_nat(x, y))
plus_nat(0, x) → x
mult_nat(0, y) → 0
The set Q consists of the following terms:
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
mult_nat(0, x0)
mult_nat(s(x0), 0)
mult_nat(s(x0), s(x1))
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule COND1(true, pos(s(s(z0)))) → COND2(equal_int(pos(if(true, mod_nat(minus_nat_s(s(z0), s(0)), s(s(0))), s(s(z0)))), pos(0)), pos(s(s(z0)))) at position [0,0,0] we obtained the following new rules [LPAR04]:
COND1(true, pos(s(s(z0)))) → COND2(equal_int(pos(mod_nat(minus_nat_s(s(z0), s(0)), s(s(0)))), pos(0)), pos(s(s(z0))))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ RemovalProof
↳ RemovalProof
↳ Narrowing
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
Q DP problem:
The TRS P consists of the following rules:
F(pos(s(s(x0)))) → COND1(true, pos(s(s(x0))))
COND2(false, pos(x1)) → F(pos(s(mult_nat(s(s(s(0))), x1))))
COND1(true, pos(s(s(z0)))) → COND2(equal_int(pos(mod_nat(minus_nat_s(s(z0), s(0)), s(s(0)))), pos(0)), pos(s(s(z0))))
The TRS R consists of the following rules:
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
equal_int(pos(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
mult_nat(s(x), 0) → 0
mult_nat(s(x), s(y)) → plus_nat(mult_nat(x, s(y)), s(y))
plus_nat(s(x), y) → s(plus_nat(x, y))
plus_nat(0, x) → x
mult_nat(0, y) → 0
The set Q consists of the following terms:
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
mult_nat(0, x0)
mult_nat(s(x0), 0)
mult_nat(s(x0), s(x1))
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule COND1(true, pos(s(s(z0)))) → COND2(equal_int(pos(mod_nat(minus_nat_s(s(z0), s(0)), s(s(0)))), pos(0)), pos(s(s(z0)))) at position [0,0,0,0] we obtained the following new rules [LPAR04]:
COND1(true, pos(s(s(z0)))) → COND2(equal_int(pos(mod_nat(minus_nat_s(z0, 0), s(s(0)))), pos(0)), pos(s(s(z0))))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ RemovalProof
↳ RemovalProof
↳ Narrowing
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
Q DP problem:
The TRS P consists of the following rules:
F(pos(s(s(x0)))) → COND1(true, pos(s(s(x0))))
COND2(false, pos(x1)) → F(pos(s(mult_nat(s(s(s(0))), x1))))
COND1(true, pos(s(s(z0)))) → COND2(equal_int(pos(mod_nat(minus_nat_s(z0, 0), s(s(0)))), pos(0)), pos(s(s(z0))))
The TRS R consists of the following rules:
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
equal_int(pos(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
mult_nat(s(x), 0) → 0
mult_nat(s(x), s(y)) → plus_nat(mult_nat(x, s(y)), s(y))
plus_nat(s(x), y) → s(plus_nat(x, y))
plus_nat(0, x) → x
mult_nat(0, y) → 0
The set Q consists of the following terms:
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
mult_nat(0, x0)
mult_nat(s(x0), 0)
mult_nat(s(x0), s(x1))
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule COND1(true, pos(s(s(z0)))) → COND2(equal_int(pos(mod_nat(minus_nat_s(z0, 0), s(s(0)))), pos(0)), pos(s(s(z0)))) at position [0,0,0,0] we obtained the following new rules [LPAR04]:
COND1(true, pos(s(s(z0)))) → COND2(equal_int(pos(mod_nat(z0, s(s(0)))), pos(0)), pos(s(s(z0))))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ RemovalProof
↳ RemovalProof
↳ Narrowing
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
Q DP problem:
The TRS P consists of the following rules:
F(pos(s(s(x0)))) → COND1(true, pos(s(s(x0))))
COND2(false, pos(x1)) → F(pos(s(mult_nat(s(s(s(0))), x1))))
COND1(true, pos(s(s(z0)))) → COND2(equal_int(pos(mod_nat(z0, s(s(0)))), pos(0)), pos(s(s(z0))))
The TRS R consists of the following rules:
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
equal_int(pos(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
mult_nat(s(x), 0) → 0
mult_nat(s(x), s(y)) → plus_nat(mult_nat(x, s(y)), s(y))
plus_nat(s(x), y) → s(plus_nat(x, y))
plus_nat(0, x) → x
mult_nat(0, y) → 0
The set Q consists of the following terms:
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
mult_nat(0, x0)
mult_nat(s(x0), 0)
mult_nat(s(x0), s(x1))
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By instantiating [LPAR04] the rule COND2(false, pos(x1)) → F(pos(s(mult_nat(s(s(s(0))), x1)))) we obtained the following new rules [LPAR04]:
COND2(false, pos(s(s(z0)))) → F(pos(s(mult_nat(s(s(s(0))), s(s(z0))))))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ RemovalProof
↳ RemovalProof
↳ Narrowing
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
F(pos(s(s(x0)))) → COND1(true, pos(s(s(x0))))
COND1(true, pos(s(s(z0)))) → COND2(equal_int(pos(mod_nat(z0, s(s(0)))), pos(0)), pos(s(s(z0))))
COND2(false, pos(s(s(z0)))) → F(pos(s(mult_nat(s(s(s(0))), s(s(z0))))))
The TRS R consists of the following rules:
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
equal_int(pos(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
mult_nat(s(x), 0) → 0
mult_nat(s(x), s(y)) → plus_nat(mult_nat(x, s(y)), s(y))
plus_nat(s(x), y) → s(plus_nat(x, y))
plus_nat(0, x) → x
mult_nat(0, y) → 0
The set Q consists of the following terms:
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
mult_nat(0, x0)
mult_nat(s(x0), 0)
mult_nat(s(x0), s(x1))
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ RemovalProof
↳ RemovalProof
↳ Narrowing
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Rewriting
Q DP problem:
The TRS P consists of the following rules:
F(pos(s(s(x0)))) → COND1(true, pos(s(s(x0))))
COND1(true, pos(s(s(z0)))) → COND2(equal_int(pos(mod_nat(z0, s(s(0)))), pos(0)), pos(s(s(z0))))
COND2(false, pos(s(s(z0)))) → F(pos(s(mult_nat(s(s(s(0))), s(s(z0))))))
The TRS R consists of the following rules:
mult_nat(s(x), s(y)) → plus_nat(mult_nat(x, s(y)), s(y))
mult_nat(0, y) → 0
plus_nat(s(x), y) → s(plus_nat(x, y))
plus_nat(0, x) → x
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
equal_int(pos(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
The set Q consists of the following terms:
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
mult_nat(0, x0)
mult_nat(s(x0), 0)
mult_nat(s(x0), s(x1))
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule COND2(false, pos(s(s(z0)))) → F(pos(s(mult_nat(s(s(s(0))), s(s(z0)))))) at position [0,0,0] we obtained the following new rules [LPAR04]:
COND2(false, pos(s(s(z0)))) → F(pos(s(plus_nat(mult_nat(s(s(0)), s(s(z0))), s(s(z0))))))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ RemovalProof
↳ RemovalProof
↳ Narrowing
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
Q DP problem:
The TRS P consists of the following rules:
F(pos(s(s(x0)))) → COND1(true, pos(s(s(x0))))
COND1(true, pos(s(s(z0)))) → COND2(equal_int(pos(mod_nat(z0, s(s(0)))), pos(0)), pos(s(s(z0))))
COND2(false, pos(s(s(z0)))) → F(pos(s(plus_nat(mult_nat(s(s(0)), s(s(z0))), s(s(z0))))))
The TRS R consists of the following rules:
mult_nat(s(x), s(y)) → plus_nat(mult_nat(x, s(y)), s(y))
mult_nat(0, y) → 0
plus_nat(s(x), y) → s(plus_nat(x, y))
plus_nat(0, x) → x
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
equal_int(pos(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
The set Q consists of the following terms:
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
mult_nat(0, x0)
mult_nat(s(x0), 0)
mult_nat(s(x0), s(x1))
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule COND2(false, pos(s(s(z0)))) → F(pos(s(plus_nat(mult_nat(s(s(0)), s(s(z0))), s(s(z0)))))) at position [0,0,0,0] we obtained the following new rules [LPAR04]:
COND2(false, pos(s(s(z0)))) → F(pos(s(plus_nat(plus_nat(mult_nat(s(0), s(s(z0))), s(s(z0))), s(s(z0))))))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ RemovalProof
↳ RemovalProof
↳ Narrowing
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
Q DP problem:
The TRS P consists of the following rules:
F(pos(s(s(x0)))) → COND1(true, pos(s(s(x0))))
COND1(true, pos(s(s(z0)))) → COND2(equal_int(pos(mod_nat(z0, s(s(0)))), pos(0)), pos(s(s(z0))))
COND2(false, pos(s(s(z0)))) → F(pos(s(plus_nat(plus_nat(mult_nat(s(0), s(s(z0))), s(s(z0))), s(s(z0))))))
The TRS R consists of the following rules:
mult_nat(s(x), s(y)) → plus_nat(mult_nat(x, s(y)), s(y))
mult_nat(0, y) → 0
plus_nat(s(x), y) → s(plus_nat(x, y))
plus_nat(0, x) → x
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
equal_int(pos(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
The set Q consists of the following terms:
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
mult_nat(0, x0)
mult_nat(s(x0), 0)
mult_nat(s(x0), s(x1))
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule COND2(false, pos(s(s(z0)))) → F(pos(s(plus_nat(plus_nat(mult_nat(s(0), s(s(z0))), s(s(z0))), s(s(z0)))))) at position [0,0,0,0,0] we obtained the following new rules [LPAR04]:
COND2(false, pos(s(s(z0)))) → F(pos(s(plus_nat(plus_nat(plus_nat(mult_nat(0, s(s(z0))), s(s(z0))), s(s(z0))), s(s(z0))))))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ RemovalProof
↳ RemovalProof
↳ Narrowing
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
F(pos(s(s(x0)))) → COND1(true, pos(s(s(x0))))
COND1(true, pos(s(s(z0)))) → COND2(equal_int(pos(mod_nat(z0, s(s(0)))), pos(0)), pos(s(s(z0))))
COND2(false, pos(s(s(z0)))) → F(pos(s(plus_nat(plus_nat(plus_nat(mult_nat(0, s(s(z0))), s(s(z0))), s(s(z0))), s(s(z0))))))
The TRS R consists of the following rules:
mult_nat(s(x), s(y)) → plus_nat(mult_nat(x, s(y)), s(y))
mult_nat(0, y) → 0
plus_nat(s(x), y) → s(plus_nat(x, y))
plus_nat(0, x) → x
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
equal_int(pos(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
The set Q consists of the following terms:
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
mult_nat(0, x0)
mult_nat(s(x0), 0)
mult_nat(s(x0), s(x1))
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ RemovalProof
↳ RemovalProof
↳ Narrowing
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Rewriting
Q DP problem:
The TRS P consists of the following rules:
F(pos(s(s(x0)))) → COND1(true, pos(s(s(x0))))
COND1(true, pos(s(s(z0)))) → COND2(equal_int(pos(mod_nat(z0, s(s(0)))), pos(0)), pos(s(s(z0))))
COND2(false, pos(s(s(z0)))) → F(pos(s(plus_nat(plus_nat(plus_nat(mult_nat(0, s(s(z0))), s(s(z0))), s(s(z0))), s(s(z0))))))
The TRS R consists of the following rules:
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
equal_int(pos(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
mult_nat(0, y) → 0
plus_nat(s(x), y) → s(plus_nat(x, y))
plus_nat(0, x) → x
The set Q consists of the following terms:
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
mult_nat(0, x0)
mult_nat(s(x0), 0)
mult_nat(s(x0), s(x1))
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule COND2(false, pos(s(s(z0)))) → F(pos(s(plus_nat(plus_nat(plus_nat(mult_nat(0, s(s(z0))), s(s(z0))), s(s(z0))), s(s(z0)))))) at position [0,0,0,0,0,0] we obtained the following new rules [LPAR04]:
COND2(false, pos(s(s(z0)))) → F(pos(s(plus_nat(plus_nat(plus_nat(0, s(s(z0))), s(s(z0))), s(s(z0))))))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ RemovalProof
↳ RemovalProof
↳ Narrowing
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
Q DP problem:
The TRS P consists of the following rules:
F(pos(s(s(x0)))) → COND1(true, pos(s(s(x0))))
COND1(true, pos(s(s(z0)))) → COND2(equal_int(pos(mod_nat(z0, s(s(0)))), pos(0)), pos(s(s(z0))))
COND2(false, pos(s(s(z0)))) → F(pos(s(plus_nat(plus_nat(plus_nat(0, s(s(z0))), s(s(z0))), s(s(z0))))))
The TRS R consists of the following rules:
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
equal_int(pos(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
mult_nat(0, y) → 0
plus_nat(s(x), y) → s(plus_nat(x, y))
plus_nat(0, x) → x
The set Q consists of the following terms:
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
mult_nat(0, x0)
mult_nat(s(x0), 0)
mult_nat(s(x0), s(x1))
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ RemovalProof
↳ RemovalProof
↳ Narrowing
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
Q DP problem:
The TRS P consists of the following rules:
F(pos(s(s(x0)))) → COND1(true, pos(s(s(x0))))
COND1(true, pos(s(s(z0)))) → COND2(equal_int(pos(mod_nat(z0, s(s(0)))), pos(0)), pos(s(s(z0))))
COND2(false, pos(s(s(z0)))) → F(pos(s(plus_nat(plus_nat(plus_nat(0, s(s(z0))), s(s(z0))), s(s(z0))))))
The TRS R consists of the following rules:
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
equal_int(pos(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
The set Q consists of the following terms:
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
mult_nat(0, x0)
mult_nat(s(x0), 0)
mult_nat(s(x0), s(x1))
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].
mult_nat(0, x0)
mult_nat(s(x0), 0)
mult_nat(s(x0), s(x1))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ RemovalProof
↳ RemovalProof
↳ Narrowing
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
Q DP problem:
The TRS P consists of the following rules:
F(pos(s(s(x0)))) → COND1(true, pos(s(s(x0))))
COND1(true, pos(s(s(z0)))) → COND2(equal_int(pos(mod_nat(z0, s(s(0)))), pos(0)), pos(s(s(z0))))
COND2(false, pos(s(s(z0)))) → F(pos(s(plus_nat(plus_nat(plus_nat(0, s(s(z0))), s(s(z0))), s(s(z0))))))
The TRS R consists of the following rules:
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
equal_int(pos(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
The set Q consists of the following terms:
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule COND2(false, pos(s(s(z0)))) → F(pos(s(plus_nat(plus_nat(plus_nat(0, s(s(z0))), s(s(z0))), s(s(z0)))))) at position [0,0,0,0,0] we obtained the following new rules [LPAR04]:
COND2(false, pos(s(s(z0)))) → F(pos(s(plus_nat(plus_nat(s(s(z0)), s(s(z0))), s(s(z0))))))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ RemovalProof
↳ RemovalProof
↳ Narrowing
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
Q DP problem:
The TRS P consists of the following rules:
F(pos(s(s(x0)))) → COND1(true, pos(s(s(x0))))
COND1(true, pos(s(s(z0)))) → COND2(equal_int(pos(mod_nat(z0, s(s(0)))), pos(0)), pos(s(s(z0))))
COND2(false, pos(s(s(z0)))) → F(pos(s(plus_nat(plus_nat(s(s(z0)), s(s(z0))), s(s(z0))))))
The TRS R consists of the following rules:
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
equal_int(pos(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
The set Q consists of the following terms:
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule COND2(false, pos(s(s(z0)))) → F(pos(s(plus_nat(plus_nat(s(s(z0)), s(s(z0))), s(s(z0)))))) at position [0,0,0,0] we obtained the following new rules [LPAR04]:
COND2(false, pos(s(s(z0)))) → F(pos(s(plus_nat(s(plus_nat(s(z0), s(s(z0)))), s(s(z0))))))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ RemovalProof
↳ RemovalProof
↳ Narrowing
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
Q DP problem:
The TRS P consists of the following rules:
F(pos(s(s(x0)))) → COND1(true, pos(s(s(x0))))
COND1(true, pos(s(s(z0)))) → COND2(equal_int(pos(mod_nat(z0, s(s(0)))), pos(0)), pos(s(s(z0))))
COND2(false, pos(s(s(z0)))) → F(pos(s(plus_nat(s(plus_nat(s(z0), s(s(z0)))), s(s(z0))))))
The TRS R consists of the following rules:
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
equal_int(pos(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
The set Q consists of the following terms:
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule COND2(false, pos(s(s(z0)))) → F(pos(s(plus_nat(s(plus_nat(s(z0), s(s(z0)))), s(s(z0)))))) at position [0,0,0] we obtained the following new rules [LPAR04]:
COND2(false, pos(s(s(z0)))) → F(pos(s(s(plus_nat(plus_nat(s(z0), s(s(z0))), s(s(z0)))))))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ RemovalProof
↳ RemovalProof
↳ Narrowing
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
Q DP problem:
The TRS P consists of the following rules:
F(pos(s(s(x0)))) → COND1(true, pos(s(s(x0))))
COND1(true, pos(s(s(z0)))) → COND2(equal_int(pos(mod_nat(z0, s(s(0)))), pos(0)), pos(s(s(z0))))
COND2(false, pos(s(s(z0)))) → F(pos(s(s(plus_nat(plus_nat(s(z0), s(s(z0))), s(s(z0)))))))
The TRS R consists of the following rules:
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
equal_int(pos(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
The set Q consists of the following terms:
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule COND2(false, pos(s(s(z0)))) → F(pos(s(s(plus_nat(plus_nat(s(z0), s(s(z0))), s(s(z0))))))) at position [0,0,0,0,0] we obtained the following new rules [LPAR04]:
COND2(false, pos(s(s(z0)))) → F(pos(s(s(plus_nat(s(plus_nat(z0, s(s(z0)))), s(s(z0)))))))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ RemovalProof
↳ RemovalProof
↳ Narrowing
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
Q DP problem:
The TRS P consists of the following rules:
F(pos(s(s(x0)))) → COND1(true, pos(s(s(x0))))
COND1(true, pos(s(s(z0)))) → COND2(equal_int(pos(mod_nat(z0, s(s(0)))), pos(0)), pos(s(s(z0))))
COND2(false, pos(s(s(z0)))) → F(pos(s(s(plus_nat(s(plus_nat(z0, s(s(z0)))), s(s(z0)))))))
The TRS R consists of the following rules:
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
equal_int(pos(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
The set Q consists of the following terms:
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule COND2(false, pos(s(s(z0)))) → F(pos(s(s(plus_nat(s(plus_nat(z0, s(s(z0)))), s(s(z0))))))) at position [0,0,0,0] we obtained the following new rules [LPAR04]:
COND2(false, pos(s(s(z0)))) → F(pos(s(s(s(plus_nat(plus_nat(z0, s(s(z0))), s(s(z0))))))))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ RemovalProof
↳ RemovalProof
↳ Narrowing
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
Q DP problem:
The TRS P consists of the following rules:
F(pos(s(s(x0)))) → COND1(true, pos(s(s(x0))))
COND1(true, pos(s(s(z0)))) → COND2(equal_int(pos(mod_nat(z0, s(s(0)))), pos(0)), pos(s(s(z0))))
COND2(false, pos(s(s(z0)))) → F(pos(s(s(s(plus_nat(plus_nat(z0, s(s(z0))), s(s(z0))))))))
The TRS R consists of the following rules:
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
equal_int(pos(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
The set Q consists of the following terms:
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By instantiating [LPAR04] the rule F(pos(s(s(x0)))) → COND1(true, pos(s(s(x0)))) we obtained the following new rules [LPAR04]:
F(pos(s(s(s(y_1))))) → COND1(true, pos(s(s(s(y_1)))))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ RemovalProof
↳ RemovalProof
↳ Narrowing
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Instantiation
Q DP problem:
The TRS P consists of the following rules:
COND1(true, pos(s(s(z0)))) → COND2(equal_int(pos(mod_nat(z0, s(s(0)))), pos(0)), pos(s(s(z0))))
COND2(false, pos(s(s(z0)))) → F(pos(s(s(s(plus_nat(plus_nat(z0, s(s(z0))), s(s(z0))))))))
F(pos(s(s(s(y_1))))) → COND1(true, pos(s(s(s(y_1)))))
The TRS R consists of the following rules:
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
equal_int(pos(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
The set Q consists of the following terms:
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By instantiating [LPAR04] the rule COND1(true, pos(s(s(z0)))) → COND2(equal_int(pos(mod_nat(z0, s(s(0)))), pos(0)), pos(s(s(z0)))) we obtained the following new rules [LPAR04]:
COND1(true, pos(s(s(s(z0))))) → COND2(equal_int(pos(mod_nat(s(z0), s(s(0)))), pos(0)), pos(s(s(s(z0)))))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ RemovalProof
↳ RemovalProof
↳ Narrowing
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
Q DP problem:
The TRS P consists of the following rules:
COND2(false, pos(s(s(z0)))) → F(pos(s(s(s(plus_nat(plus_nat(z0, s(s(z0))), s(s(z0))))))))
F(pos(s(s(s(y_1))))) → COND1(true, pos(s(s(s(y_1)))))
COND1(true, pos(s(s(s(z0))))) → COND2(equal_int(pos(mod_nat(s(z0), s(s(0)))), pos(0)), pos(s(s(s(z0)))))
The TRS R consists of the following rules:
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
equal_int(pos(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
The set Q consists of the following terms:
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule COND1(true, pos(s(s(s(z0))))) → COND2(equal_int(pos(mod_nat(s(z0), s(s(0)))), pos(0)), pos(s(s(s(z0))))) at position [0,0,0] we obtained the following new rules [LPAR04]:
COND1(true, pos(s(s(s(z0))))) → COND2(equal_int(pos(if(greatereq_int(pos(z0), pos(s(0))), mod_nat(minus_nat_s(z0, s(0)), s(s(0))), s(z0))), pos(0)), pos(s(s(s(z0)))))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ RemovalProof
↳ RemovalProof
↳ Narrowing
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
Q DP problem:
The TRS P consists of the following rules:
COND2(false, pos(s(s(z0)))) → F(pos(s(s(s(plus_nat(plus_nat(z0, s(s(z0))), s(s(z0))))))))
F(pos(s(s(s(y_1))))) → COND1(true, pos(s(s(s(y_1)))))
COND1(true, pos(s(s(s(z0))))) → COND2(equal_int(pos(if(greatereq_int(pos(z0), pos(s(0))), mod_nat(minus_nat_s(z0, s(0)), s(s(0))), s(z0))), pos(0)), pos(s(s(s(z0)))))
The TRS R consists of the following rules:
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
equal_int(pos(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
The set Q consists of the following terms:
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By instantiating [LPAR04] the rule COND2(false, pos(s(s(z0)))) → F(pos(s(s(s(plus_nat(plus_nat(z0, s(s(z0))), s(s(z0)))))))) we obtained the following new rules [LPAR04]:
COND2(false, pos(s(s(s(z0))))) → F(pos(s(s(s(plus_nat(plus_nat(s(z0), s(s(s(z0)))), s(s(s(z0)))))))))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ RemovalProof
↳ RemovalProof
↳ Narrowing
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
Q DP problem:
The TRS P consists of the following rules:
F(pos(s(s(s(y_1))))) → COND1(true, pos(s(s(s(y_1)))))
COND1(true, pos(s(s(s(z0))))) → COND2(equal_int(pos(if(greatereq_int(pos(z0), pos(s(0))), mod_nat(minus_nat_s(z0, s(0)), s(s(0))), s(z0))), pos(0)), pos(s(s(s(z0)))))
COND2(false, pos(s(s(s(z0))))) → F(pos(s(s(s(plus_nat(plus_nat(s(z0), s(s(s(z0)))), s(s(s(z0)))))))))
The TRS R consists of the following rules:
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
equal_int(pos(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
The set Q consists of the following terms:
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule COND2(false, pos(s(s(s(z0))))) → F(pos(s(s(s(plus_nat(plus_nat(s(z0), s(s(s(z0)))), s(s(s(z0))))))))) at position [0,0,0,0,0,0] we obtained the following new rules [LPAR04]:
COND2(false, pos(s(s(s(z0))))) → F(pos(s(s(s(plus_nat(s(plus_nat(z0, s(s(s(z0))))), s(s(s(z0)))))))))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ RemovalProof
↳ RemovalProof
↳ Narrowing
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
Q DP problem:
The TRS P consists of the following rules:
F(pos(s(s(s(y_1))))) → COND1(true, pos(s(s(s(y_1)))))
COND1(true, pos(s(s(s(z0))))) → COND2(equal_int(pos(if(greatereq_int(pos(z0), pos(s(0))), mod_nat(minus_nat_s(z0, s(0)), s(s(0))), s(z0))), pos(0)), pos(s(s(s(z0)))))
COND2(false, pos(s(s(s(z0))))) → F(pos(s(s(s(plus_nat(s(plus_nat(z0, s(s(s(z0))))), s(s(s(z0)))))))))
The TRS R consists of the following rules:
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
equal_int(pos(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
The set Q consists of the following terms:
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By rewriting [LPAR04] the rule COND2(false, pos(s(s(s(z0))))) → F(pos(s(s(s(plus_nat(s(plus_nat(z0, s(s(s(z0))))), s(s(s(z0))))))))) at position [0,0,0,0,0] we obtained the following new rules [LPAR04]:
COND2(false, pos(s(s(s(z0))))) → F(pos(s(s(s(s(plus_nat(plus_nat(z0, s(s(s(z0)))), s(s(s(z0))))))))))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ RemovalProof
↳ RemovalProof
↳ Narrowing
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
Q DP problem:
The TRS P consists of the following rules:
F(pos(s(s(s(y_1))))) → COND1(true, pos(s(s(s(y_1)))))
COND1(true, pos(s(s(s(z0))))) → COND2(equal_int(pos(if(greatereq_int(pos(z0), pos(s(0))), mod_nat(minus_nat_s(z0, s(0)), s(s(0))), s(z0))), pos(0)), pos(s(s(s(z0)))))
COND2(false, pos(s(s(s(z0))))) → F(pos(s(s(s(s(plus_nat(plus_nat(z0, s(s(s(z0)))), s(s(s(z0))))))))))
The TRS R consists of the following rules:
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
equal_int(pos(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
The set Q consists of the following terms:
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
By instantiating [LPAR04] the rule F(pos(s(s(s(y_1))))) → COND1(true, pos(s(s(s(y_1))))) we obtained the following new rules [LPAR04]:
F(pos(s(s(s(s(y_1)))))) → COND1(true, pos(s(s(s(s(y_1))))))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ RemovalProof
↳ RemovalProof
↳ Narrowing
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ RemovalProof
↳ RemovalProof
↳ QReductionProof
Q DP problem:
The TRS P consists of the following rules:
COND1(true, pos(s(s(s(z0))))) → COND2(equal_int(pos(if(greatereq_int(pos(z0), pos(s(0))), mod_nat(minus_nat_s(z0, s(0)), s(s(0))), s(z0))), pos(0)), pos(s(s(s(z0)))))
COND2(false, pos(s(s(s(z0))))) → F(pos(s(s(s(s(plus_nat(plus_nat(z0, s(s(s(z0)))), s(s(s(z0))))))))))
F(pos(s(s(s(s(y_1)))))) → COND1(true, pos(s(s(s(s(y_1))))))
The TRS R consists of the following rules:
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
equal_int(pos(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
The set Q consists of the following terms:
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
In the following pairs the term without variables pos(s(0)) is replaced by the fresh variable x_removed.
Pair: COND1(true, pos(s(s(s(z0))))) → COND2(equal_int(pos(if(greatereq_int(pos(z0), pos(s(0))), mod_nat(minus_nat_s(z0, s(0)), s(s(0))), s(z0))), pos(0)), pos(s(s(s(z0)))))
Positions in right side of the pair: The new variable was added to all pairs as a new argument[CONREM].
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ RemovalProof
↳ RemovalProof
↳ Narrowing
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ RemovalProof
↳ QDP
↳ RemovalProof
↳ QReductionProof
Q DP problem:
The TRS P consists of the following rules:
COND1(true, pos(s(s(s(z0)))), x_removed) → COND2(equal_int(pos(if(greatereq_int(pos(z0), x_removed), mod_nat(minus_nat_s(z0, s(0)), s(s(0))), s(z0))), pos(0)), pos(s(s(s(z0)))), x_removed)
COND2(false, pos(s(s(s(z0)))), x_removed) → F(pos(s(s(s(s(plus_nat(plus_nat(z0, s(s(s(z0)))), s(s(s(z0))))))))), x_removed)
F(pos(s(s(s(s(y_1))))), x_removed) → COND1(true, pos(s(s(s(s(y_1))))), x_removed)
The TRS R consists of the following rules:
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
equal_int(pos(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
The set Q consists of the following terms:
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
In the following pairs the term without variables pos(s(0)) is replaced by the fresh variable x_removed.
Pair: COND1(true, pos(s(s(s(z0))))) → COND2(equal_int(pos(if(greatereq_int(pos(z0), pos(s(0))), mod_nat(minus_nat_s(z0, s(0)), s(s(0))), s(z0))), pos(0)), pos(s(s(s(z0)))))
Positions in right side of the pair: The new variable was added to all pairs as a new argument[CONREM].
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ RemovalProof
↳ RemovalProof
↳ Narrowing
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ RemovalProof
↳ RemovalProof
↳ QDP
↳ QReductionProof
Q DP problem:
The TRS P consists of the following rules:
COND1(true, pos(s(s(s(z0)))), x_removed) → COND2(equal_int(pos(if(greatereq_int(pos(z0), x_removed), mod_nat(minus_nat_s(z0, s(0)), s(s(0))), s(z0))), pos(0)), pos(s(s(s(z0)))), x_removed)
COND2(false, pos(s(s(s(z0)))), x_removed) → F(pos(s(s(s(s(plus_nat(plus_nat(z0, s(s(s(z0)))), s(s(s(z0))))))))), x_removed)
F(pos(s(s(s(s(y_1))))), x_removed) → COND1(true, pos(s(s(s(s(y_1))))), x_removed)
The TRS R consists of the following rules:
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
equal_int(pos(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
The set Q consists of the following terms:
greatereq_int(pos(x0), pos(0))
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(pos(s(x0)), pos(s(x1)))
greatereq_int(neg(s(x0)), neg(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
equal_int(pos(0), pos(0))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(pos(0), pos(s(x0)))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(pos(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as they contain symbols which do neither occur in P nor in R.[THIEMANN].
greatereq_int(neg(0), pos(0))
greatereq_int(neg(0), neg(x0))
greatereq_int(pos(x0), neg(x1))
greatereq_int(neg(x0), pos(s(x1)))
greatereq_int(neg(s(x0)), pos(0))
greatereq_int(neg(s(x0)), neg(0))
greatereq_int(neg(s(x0)), neg(s(x1)))
equal_int(neg(0), pos(0))
equal_int(neg(0), neg(0))
equal_int(pos(0), neg(0))
equal_int(neg(0), pos(s(x0)))
equal_int(pos(0), neg(s(x0)))
equal_int(neg(0), neg(s(x0)))
equal_int(pos(s(x0)), neg(0))
equal_int(neg(s(x0)), pos(0))
equal_int(neg(s(x0)), neg(0))
equal_int(pos(s(x0)), neg(s(x1)))
equal_int(neg(s(x0)), pos(s(x1)))
equal_int(neg(s(x0)), neg(s(x1)))
↳ ITRS
↳ ITRStoIDPProof
↳ IDP
↳ UsableRulesProof
↳ IDP
↳ IDPtoQDPProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ QDPOrderProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ RemovalProof
↳ RemovalProof
↳ Narrowing
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Narrowing
↳ QDP
↳ DependencyGraphProof
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ Rewriting
↳ QDP
↳ UsableRulesProof
↳ QDP
↳ QReductionProof
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ Rewriting
↳ QDP
↳ Rewriting
↳ QDP
↳ Instantiation
↳ QDP
↳ RemovalProof
↳ RemovalProof
↳ QReductionProof
↳ QDP
Q DP problem:
The TRS P consists of the following rules:
COND1(true, pos(s(s(s(z0))))) → COND2(equal_int(pos(if(greatereq_int(pos(z0), pos(s(0))), mod_nat(minus_nat_s(z0, s(0)), s(s(0))), s(z0))), pos(0)), pos(s(s(s(z0)))))
COND2(false, pos(s(s(s(z0))))) → F(pos(s(s(s(s(plus_nat(plus_nat(z0, s(s(s(z0)))), s(s(s(z0))))))))))
F(pos(s(s(s(s(y_1)))))) → COND1(true, pos(s(s(s(s(y_1))))))
The TRS R consists of the following rules:
plus_nat(0, x) → x
plus_nat(s(x), y) → s(plus_nat(x, y))
mod_nat(0, s(x)) → 0
mod_nat(s(x), s(y)) → if(greatereq_int(pos(x), pos(y)), mod_nat(minus_nat_s(x, y), s(y)), s(x))
equal_int(pos(0), pos(0)) → true
equal_int(pos(s(x)), pos(0)) → false
greatereq_int(pos(x), pos(0)) → true
greatereq_int(pos(0), pos(s(y))) → false
greatereq_int(pos(s(x)), pos(s(y))) → greatereq_int(pos(x), pos(y))
minus_nat_s(x, 0) → x
minus_nat_s(0, s(y)) → 0
minus_nat_s(s(x), s(y)) → minus_nat_s(x, y)
if(true, x, y) → x
if(false, x, y) → y
The set Q consists of the following terms:
greatereq_int(pos(x0), pos(0))
greatereq_int(pos(0), pos(s(x0)))
greatereq_int(pos(s(x0)), pos(s(x1)))
if(true, x0, x1)
if(false, x0, x1)
minus_nat_s(x0, 0)
minus_nat_s(0, s(x0))
minus_nat_s(s(x0), s(x1))
plus_nat(0, x0)
plus_nat(s(x0), x1)
equal_int(pos(0), pos(0))
equal_int(pos(0), pos(s(x0)))
equal_int(pos(s(x0)), pos(0))
equal_int(pos(s(x0)), pos(s(x1)))
mod_nat(0, s(x0))
mod_nat(s(x0), s(x1))
We have to consider all (P,Q,R)-chains.